{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **演示0502：最小二乘法**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **单变量线性拟合**\n",
    "* 假设平面上有若干个数据点$(x_i, y_i)$，其中$i=1,2,\\cdots,n$。$x$作为唯一的自变量，$y$作为因变量。作一条曲线，使得**各数据点到该曲线的距离最近**：\n",
    "\n",
    "![](../images/050201.png)\n",
    "\n",
    "* 如何定义**各数据点到该曲线的距离最近**\n",
    " * 首先定义残差概念如下：$r_i=h(x_i )-y_i$，其中$h(x_i )$代表拟合后的曲线函数在第$i$个数据点$x_i$处的计算结果\n",
    " * 根据范数的定义，可知：\n",
    "   * 正无穷范数(残差绝对值的最大值)：$ F(+\\infty)=max(|r_i|)$\n",
    "   * 1范数(残差绝对值之和)：$F(1)=\\sum_i^n|r_i |$\n",
    "   * 2范数(残差平方和)：$ F(2)=\\sum_i^n r_i^2 $\n",
    " * 一般使用2范数的大小来判断**各数据点到该曲线的距离最近**，这种方法就称为最小二乘法(Least Square Method)\n",
    "* 拟合曲线的类型\n",
    " * 可以使用直线、二次曲线、高阶曲线等进行拟合\n",
    " * 无论哪种曲线，都可以表示成：$ h(x)= w_0+w_1 x+ w_2 x^2+\\cdots+w_m x^m $，其中，$m$指定了拟合曲线的最大阶数\n",
    " * 最小二乘法的目标，就是要找到向量$w=(w_0,w_1,\\cdots,w_m )$，使得针对所有的数据点，残差的2范数最小\n",
    " * 当$m=1$时，拟合结果就是一条直线"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **案例1：一元(单变量)数据点集线性拟合**\n",
    "已知二维平面上若干数据点坐标$(x_i, y_i)$如下：(6, 7), (8, 9), (10, 13), (14, 17.5), (18, 18)  \n",
    "拟合出一条直线：$ y = w_1 x + w_0 $，使用最小二乘法计算出最优的权重系数(参数)$w_1$和$w_0$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **步骤1：查看数据点的图像**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD8CAYAAABn919SAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAADrtJREFUeJzt3V9snfV5wPHvsyQdDhp1WEzbBFhoVTyplJHWrRhaRwtFzgUiUa+KihSpaJGY1KqR6rYREoirIoxUVZo0FI0saKsitchNe9MZxEVzwx8ZAiQM3EwqDbFZYxS5F6vXhvTZhY9ZMHGOz3v+vMe/fD9SdM75nTd5n1eJvxy/57wmMhNJ0tr3Z3UPIEnqDIMuSYUw6JJUCIMuSYUw6JJUCIMuSYUw6JJUCIMuSYUw6JJUiPW93NnmzZtz27ZtvdylJK15L7744juZOdRsu54Gfdu2bUxNTfVyl5K05kXEb1aznadcJKkQBl2SCmHQJakQBl2SCmHQJakQTT/lEhEHgDuB05l5Q2PtJuAx4DLgXeAfM/OFbg4qSWvN4aMzjE9OMzu/wJbBAcZGh9m1fWvX9reaV+gHgR3L1h4BHsrMm4AHGo8lSQ2Hj86wb+IYM/MLJDAzv8C+iWMcPjrTtX02DXpmHgHOLF8Grmjc/zAw2+G5JGlNG5+cZuHsufetLZw9x/jkdNf2WfXCom8BkxHxKIv/UbhlpQ0jYg+wB+Daa6+tuDtJWltm5xdaWu+Eqm+K3gfszcxrgL3A4yttmJn7M3MkM0eGhppeuSpJRdgyONDSeidUDfpuYKJx/yfA5zszjiSVYWx0mIEN6963NrBhHWOjw13bZ9WgzwK3Nu7fBpzozDiSVIZd27fy/a98mq2DAwSwdXCA73/l0139lMtqPrZ4CPgisDkiTgEPAv8A/DAi1gP/S+McuSTp/+3avrWrAV+uadAz8+4Vnvpsh2eRJLWhpz8+V1L39PoiFvUfgy4VYOkilqXPPS9dxAIY9UuIP8tFKkAdF7Go/xh0qQB1XMSi/mPQpQLUcRGL+o9BlwpQx0Us6j++KSoVYOmNTz/lcmkz6FIhen0Ri/qPp1wkqRAGXZIKYdAlqRAGXZIKYdAlqRAGXZIKYdAlqRAGXZIKYdAlqRAGXZIKYdAlqRAGXZIKYdAlqRAGXZIKYdAlqRAGXZIKYdAlqRAGXZIKYdAlqRBNgx4RByLidEQcX7b+jYiYjojXIuKR7o0oSVqN1bxCPwjsOH8hIr4E7ARuzMxPAY92fjRJUiuaBj0zjwBnli3fBzycmX9obHO6C7NJklpQ9Rz69cAXIuL5iPhlRHxupQ0jYk9ETEXE1NzcXMXdSZKaqRr09cAm4GZgDPhxRMSFNszM/Zk5kpkjQ0NDFXcnSWqmatBPARO56AXgT8Dmzo0lSWpV1aAfBm4DiIjrgQ8B73RqKElS69Y32yAiDgFfBDZHxCngQeAAcKDxUcY/ArszM7s5qCTp4poGPTPvXuGpezo8iySpDV4pKkmFMOiSVAiDLkmFMOiSVAiDLkmFMOiSVAiDLkmFMOiSVAiDLkmFMOiSVAiDLkmFMOiSVAiDLkmFMOiSVAiDLkmFMOiSVAiDLkmFMOiSVAiDLkmFMOiSVAiDLkmFMOiSVAiDLkmFMOiSVAiDLkmFMOiSVAiDLkmFaBr0iDgQEacj4vgFnvt2RGREbO7OeJKk1VrNK/SDwI7lixFxDXAHcLLDM0mSKmga9Mw8Apy5wFM/AL4DZKeHkiS1rtI59Ii4C5jJzFdWse2eiJiKiKm5ubkqu5MkrULLQY+IjcD9wAOr2T4z92fmSGaODA0Ntbo7SdIqVXmF/gngOuCViHgTuBp4KSI+2snBJEmtWd/qb8jMY8BVS48bUR/JzHc6OJckqUWr+djiIeBZYDgiTkXEvd0fS5LUqqav0DPz7ibPb+vYNJKkyrxSVJIKYdAlqRAGXZIKYdAlqRAGXZIKYdAlqRAGXZIKYdAlqRAGXZIK0fLPcpEADh+dYXxymtn5BbYMDjA2Osyu7VvrHku6pBl0tezw0Rn2TRxj4ew5AGbmF9g3cQzAqEs18pSLWjY+Of1ezJcsnD3H+OR0TRNJAoOuCmbnF1pal9QbBl0t2zI40NK6pN4w6GrZ2OgwAxvWvW9tYMM6xkaHa5pIEvimqCpYeuPTT7lI/cWgq5Jd27cacKnPeMpFkgph0CWpEAZdkgph0CWpEAZdkgph0CWpEAZdkgph0CWpEAZdkgrRNOgRcSAiTkfE8fPWxiPijYh4NSJ+GhGD3R1TktTMal6hHwR2LFt7GrghM28EfgXs6/BckqQWNQ16Zh4Bzixbeyoz3208fA64uguzSZJa0Ilz6F8HftGBP0eS1Ia2gh4R9wPvAj+6yDZ7ImIqIqbm5uba2Z0k6SIqBz0idgN3Al/LzFxpu8zcn5kjmTkyNDRUdXeSpCYq/Tz0iNgBfBe4NTN/39mRJElVrOZji4eAZ4HhiDgVEfcC/wT8BfB0RLwcEY91eU5JUhNNX6Fn5t0XWH68C7NIktrglaKSVAiDLkmFMOiSVAiDLkmFMOiSVAiDLkmFMOiSVAiDLkmFMOiSVAiDLkmFMOiSVAiDLkmFMOiSVAiDLkmFMOiSVAiDLkmFMOiSVAiDLkmFMOiSVAiDLkmFMOiSVAiDLkmFMOiSVAiDLkmFMOiSVAiDLkmFMOiSVIimQY+IAxFxOiKOn7d2ZUQ8HREnGrebujumJKmZ1bxCPwjsWLb2PeCZzPwk8EzjsSSpRk2DnplHgDPLlncCTzTuPwHs6vBckqQWVT2H/pHMfBugcXtV50aSJFXR9TdFI2JPRExFxNTc3Fy3dydJl6yqQf9tRHwMoHF7eqUNM3N/Zo5k5sjQ0FDF3UmSmqka9J8Duxv3dwM/68w4kqSqVvOxxUPAs8BwRJyKiHuBh4E7IuIEcEfjsSSpRuubbZCZd6/w1O0dnkWS1AavFJWkQhh0SSqEQZekQhh0SSqEQZekQhh0SSqEQZekQhh0SSqEQZekQhh0SSpE00v/1TmHj84wPjnN7PwCWwYHGBsdZtf2rXWPJakQBr1HDh+dYd/EMRbOngNgZn6BfRPHAIy6pI7wlEuPjE9OvxfzJQtnzzE+OV3TRJJKY9B7ZHZ+oaV1SWqVQe+RLYMDLa1LUqsMeo+MjQ4zsGHd+9YGNqxjbHS4pokklcY3RXtk6Y1PP+UiqVsMeg/t2r7VgEvqGk+5SFIhDLokFcKgS1IhDLokFcKgS1IhDLokFcKgS1IhDLokFcKgS1Ih2gp6ROyNiNci4nhEHIqIyzo1mCSpNZWDHhFbgW8CI5l5A7AO+GqnBpMktabdUy7rgYGIWA9sBGbbH0mSVEXloGfmDPAocBJ4G/hdZj7VqcEkSa1p55TLJmAncB2wBbg8Iu65wHZ7ImIqIqbm5uaqTypJuqh2Trl8Gfh1Zs5l5llgArhl+UaZuT8zRzJzZGhoqI3dSZIupp2gnwRujoiNERHA7cDrnRlLktSqds6hPw88CbwEHGv8Wfs7NJckqUVt/R+LMvNB4MEOzSJJaoNXikpSIQy6JBXCoEtSIQy6JBXCoEtSIQy6JBXCoEtSIQy6JBXCoEtSIQy6JBWirUv/e+Hw0RnGJ6eZnV9gy+AAY6PD7Nq+te6xJKnv9HXQDx+dYd/EMRbOngNgZn6BfRPHAIy6JC3T16dcxien34v5koWz5xifnK5pIknqX30d9Nn5hZbWJelS1tdB3zI40NK6JF3K+jroY6PDDGxY9761gQ3rGBsdrmkiSepfff2m6NIbn37KRZKa6+ugw2LUDbgkNdfXp1wkSatn0CWpEAZdkgph0CWpEAZdkgoRmdm7nUXMAb+p+Ns3A+90cJw6eSz9p5TjAI+lH7V7HH+VmUPNNupp0NsREVOZOVL3HJ3gsfSfUo4DPJZ+1Kvj8JSLJBXCoEtSIdZS0PfXPUAHeSz9p5TjAI+lH/XkONbMOXRJ0sWtpVfokqSLWBNBj4jBiHgyIt6IiNcj4m/rnqmqiNgbEa9FxPGIOBQRl9U902pFxIGIOB0Rx89buzIino6IE43bTXXOuBorHMd449/XqxHx04gYrHPG1brQsZz33LcjIiNicx2ztWKl44iIb0TEdONr5pG65mvFCv++boqI5yLi5YiYiojPd2PfayLowA+B/8jMvwb+Bni95nkqiYitwDeBkcy8AVgHfLXeqVpyENixbO17wDOZ+UngmcbjfneQDx7H08ANmXkj8CtgX6+HquggHzwWIuIa4A7gZK8Hquggy44jIr4E7ARuzMxPAY/WMFcVB/ng38kjwEOZeRPwQONxx/V90CPiCuDvgccBMvOPmTlf71RtWQ8MRMR6YCMwW/M8q5aZR4Azy5Z3Ak807j8B7OrpUBVc6Dgy86nMfLfx8Dng6p4PVsEKfycAPwC+A6yJN8lWOI77gIcz8w+NbU73fLAKVjiWBK5o3P8wXfq67/ugAx8H5oB/jYijEfEvEXF53UNVkZkzLL7KOAm8DfwuM5+qd6q2fSQz3wZo3F5V8zyd8HXgF3UPUVVE3AXMZOYrdc/SpuuBL0TE8xHxy4j4XN0DteFbwHhEvMViA7ryHeBaCPp64DPAP2fmduB/WBvf1n9A4/zyTuA6YAtweUTcU+9UOl9E3A+8C/yo7lmqiIiNwP0sflu/1q0HNgE3A2PAjyMi6h2psvuAvZl5DbCXxhmHTlsLQT8FnMrM5xuPn2Qx8GvRl4FfZ+ZcZp4FJoBbap6pXb+NiI8BNG7XxLfFFxIRu4E7ga/l2v087ydYfMHwSkS8yeKpo5ci4qO1TlXNKWAiF70A/InFn4myFu1m8esd4CfApfmmaGb+N/BWRCz9n6FvB/6zxpHacRK4OSI2Nl5p3M4afYP3PD9n8R8rjduf1ThLZRGxA/gucFdm/r7uearKzGOZeVVmbsvMbSxG8TONr6O15jBwG0BEXA98iLX7g7pmgVsb928DTnRlL5nZ97+Am4Ap4FUW/5I31T1TG8fyEPAGcBz4N+DP656phdkPsXju/yyLobgX+EsWP91yonF7Zd1zVjyO/wLeAl5u/Hqs7jmrHsuy598ENtc9Z8W/kw8B/974WnkJuK3uOds4lr8DXgReAZ4HPtuNfXulqCQVou9PuUiSVsegS1IhDLokFcKgS1IhDLokFcKgS1IhDLokFcKgS1Ih/g8w6mUl50bBigAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2052e7688d0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "''' 查看数据点图像 '''\n",
    "\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x = np.array([6, 8, 10, 14, 18])\n",
    "y = np.array([7, 9, 13, 17.5, 18])\n",
    "\n",
    "plt.scatter(x, y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **步骤2-方法1：使用协方差-方差公式进行直线拟合**  \n",
    ">  \n",
    "已知要拟合的目标函数：$ F(w_0,w_1 )=\\sum_i^n (w_0+w_1 x_i-y_i)^2 $，则使$F$最小的$w_0$和$w_1$可通过下列方式计算：  \n",
    "$ \\left\\{\\begin{array}{lcr}\n",
    "w_0 = \\bar y - w_1 \\bar x \\\\ \\\\\n",
    "w_1 = \\dfrac{cov(x, y)}{var(x)}\n",
    "\\end{array}\\right. $  \n",
    "其中，$ cov(x, y) $是数组$x$,$y$的协方差，$var(x)$是数组$x$的方差  \n",
    "\n",
    "**使用协方差-方差公式进行直线拟合的推导过程：**\n",
    "* 要计算函数$F$的极值，可以采用求一阶偏导，并使之为0：  \n",
    "$ \\left\\{\\begin{array}{lcr}\n",
    "\\dfrac{\\partial F}{\\partial w_0} = 2 \\sum_i^n (w_0+w_1 x_i-y_i) = 0 \\\\ \\\\\n",
    "\\dfrac{\\partial F}{\\partial w_1} = 2 \\sum_i^n (w_0+w_1 x_i-y_i) x_i = 0\n",
    "\\end{array}\\right. $\n",
    "* 根据$\\dfrac{\\partial F}{\\partial w_0}=0 $，可得：$w_0=\\bar y - w_1 \\bar x $，其中：\n",
    " * $ \\bar y $：训练数据中$y$的平均值\n",
    " * $ \\bar x $：训练数据中$x$的平均值\n",
    "* 将$w_0=\\bar y - w_1 \\bar x $代入到$\\dfrac{\\partial F}{\\partial w_1}=0 $，可得：  \n",
    "$ \\begin{aligned}\n",
    "\\dfrac{\\partial F}{\\partial w_1} &=\\sum_{i=1}^n (\\bar y - w_1 \\bar x + w_1 x_i - y_i) x_i \\\\ \\\\\n",
    "&=\\bar y \\sum{x_i} - \\sum{x_i}{y_i} - w_1 (\\bar x \\sum{x_i} - \\sum{x_i^2}) \\\\ \\\\\n",
    "&=0\n",
    "\\end{aligned}$  \n",
    "进而可得：  \n",
    "$ w_1 = \\dfrac{\\bar y \\sum{x_i} - \\sum{x_i y_i}}{\\bar x \\sum{x_i} - \\sum{x_i^2}} = \\dfrac{n \\bar y \\bar x - \\sum{x_i y_i}}{n \\bar x^2 - \\sum{x_i^2}} = \\dfrac{\\sum{x_i y_i} - n \\bar x \\bar y}{\\sum{x_i^2} - n \\bar x^2} $  \n",
    "注意，上式中用到了下列事实：$ \\sum{x_i} = n \\bar x $  \n",
    "* 引入两个重要的推论式：  \n",
    "$ \\sum_{i=1}^{n} (x_i - \\bar x)^2=\\sum{x_i^2} - n \\bar x^2 $  \n",
    "$ \\sum_{i=1}^{n} (x_i - \\bar x)(y_i - \\bar y)=\\sum{x_i y_i} - n \\bar x \\bar y $  \n",
    "证明如下：  \n",
    "$ \\begin{aligned}\n",
    "&\\sum_{i=1}^{n} (x_i - \\bar x)^2 \\\\ \\\\ = & (x_1 - \\bar x)^2 + (x_2 - \\bar x)^2 + \\cdots + (x_n - \\bar x)^2 \\\\ \\\\\n",
    "= & (x_1^2 - 2 x_1 \\bar x + \\bar x^2) +\n",
    "(x_2^2 - 2 x_2 \\bar x + \\bar x^2) + \\cdots +\n",
    "(x_n^2 - 2 x_n \\bar x + \\bar x^2) \\\\ \\\\\n",
    "= & (x_1^2 + x_2^2 + \\cdots + x_n^2) + n \\bar x^2 - 2 \\bar x (x_1 + x_2 + \\cdots + x_n) \\\\ \\\\\n",
    "= & \\sum{x_i^2} + n \\bar x^2 - 2 \\bar x * n * \\bar x \\\\ \\\\\n",
    "= & \\sum{x_i^2} - n \\bar x^2\n",
    "\\end{aligned}$  \n",
    "$\\begin{aligned} \\\\\n",
    "\\begin{aligned}\n",
    "&\\sum_{i=1}^{n} (x_i - \\bar x)(y_i - \\bar y) \\\\ \\\\\n",
    "= & (x_1 - \\bar x)(y_1 - \\bar y) + (x_2 - \\bar x)(y_2 - \\bar y) + \\cdots + (x_n - \\bar x)(y_n - \\bar y) \\\\ \\\\\n",
    "= & (x_1 y_1 + \\bar x \\bar y - x_1 \\bar y - y_1 \\bar x) + (x_2 y_2 + \\bar x \\bar y - x_2 \\bar y - y_2 \\bar x) + \\cdots + (x_n y_n + \\bar x \\bar y - x_n \\bar y - y_n \\bar x) \\\\ \\\\\n",
    "= & (x_1 y_1 + x_2 y_2 + \\cdots + x_n y_n) + n \\bar x \\bar y - \\bar y(x_1+x_2+\\cdots+x_n)-\\bar x(y_1 + y_2 + \\cdots + y_n) \\\\ \\\\\n",
    "= & \\sum{x_i y_i} + n \\bar x \\bar y - \\bar y \\cdot n \\cdot \\bar x - \\bar x \\cdot n \\cdot \\bar y \\\\ \\\\\n",
    "= & \\sum{x_i y_i} - n \\bar x \\bar y\n",
    "\\end{aligned} \\end{aligned}$  \n",
    "* 结合上述$w_0$和$w_1$计算结果及推论式，进一步得到：  \n",
    "$ \\left\\{\\begin{array}{lcr}\n",
    "w_0 = \\bar y - w_1 \\bar x \\\\ \\\\\n",
    "w_1 = \\dfrac{x_i y_i - n \\bar x \\bar y}{\\sum{x_i^2 - n \\bar x^2}} = \\dfrac{\\sum_{i=1}^{n}(x_i - \\bar x)(y_i - \\bar y)}{\\sum_{i=1}^{n}(x_i - \\bar x)^2}\n",
    "\\end{array}\\right. $  \n",
    "回顾协方差和方差的概念，上述结果也可以写成：  \n",
    "$ \\left\\{\\begin{array}{lcr}\n",
    "w_0 = \\bar y - w_1 \\bar x \\\\ \\\\\n",
    "w_1 = \\dfrac{cov(x, y)}{var(x)}\n",
    "\\end{array}\\right. $"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w1= 0.976293103448276\n",
      "w0= 1.9655172413793096\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2052e7a23c8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "''' 使用方差-协方差公式拟合曲线 '''\n",
    "w1 = np.cov(x, y, ddof=1)[1, 0] / np.var(x, ddof=1)\n",
    "w0 = np.mean(y) - w1 * np.mean(x)\n",
    "\n",
    "# 打印计算出来的w1和w0的值\n",
    "print(\"w1=\", w1)\n",
    "print(\"w0=\", w0)\n",
    "\n",
    "# 使用拟合的曲线，根据x计算对应的y值\n",
    "y_fit = w1 * x + w0\n",
    "\n",
    "# 绘制样本数据点以及拟合出来的直线\n",
    "plt.scatter(x, y)\n",
    "plt.plot(x, y_fit)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **步骤2-方法2：使用矩阵运算法求解$w_0$和$w_1$**   \n",
    ">  \n",
    "$W=(X^T X)^{-1} X^T y$  \n",
    "上式中，$X$是$(m, n)$维度数组，$m$是样本点个数，$n$是权重系数的个数。在一元线性回归中，$n$=2。本例中$X$可视为$(5, 2)$矩阵，其中一列是$x$的坐标值，另一列补充一个全为$1$的值(从而形成扩展矩阵)，以便与向量$W$(包含$w_0$和$w_1$)进行乘积运算。  \n",
    "提示：*np.linalg*包含了矩阵求逆的函数  \n",
    "\n",
    "**关于扩展矩阵$X$：**  \n",
    "* 假设有$m$个样本，每个样本包括一个$n$维度向量(多变量)和一个对应的结果值$(y)$，且$m \\ge n+1$  \n",
    "$ S=\\left(\\begin{matrix}\n",
    "x_{11} & x_{12} & \\cdots & x_{1n} \\\\\n",
    "x_{21} & x_{22} & \\cdots & x_{2n} \\\\\n",
    "\\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
    "x_{m1} & x_{m2} & \\cdots & x_{mn}\n",
    "\\end{matrix}\\right) $  \n",
    "$ y=(y_1,y_2,\\cdots,y_m)^T $  \n",
    "需要拟合成下列线性形式：$F(x)=Sa+b$，其中，$a$是$n$维向量，$b$是标量\n",
    "* 样本数据变形  \n",
    "令：$ X=\\left(\\begin{matrix}\n",
    "1 & x_{11} & x_{12} & \\cdots & x_{1n} \\\\\n",
    "1 & x_{21} & x_{22} & \\cdots & x_{2n} \\\\\n",
    "\\vdots & \\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
    "1 & x_{m1} & x_{m2} & \\cdots & x_{mn}\n",
    "\\end{matrix}\\right) $  \n",
    "也就是说，在S第1列插入一列全为1的列  \n",
    "$ w=(w_0, w_1, w_2, \\cdots, w_{n-1},w_n)^T $    \n",
    "则拟合后的函数$f=Sa+b$转变成：$f(X,w)=Xw$  \n",
    "全为1的列在$X$中的位置是可以调整的，只要保证与$w$中的$w_0$位置对应就行"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.9762931  1.96551724]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x205351b4cc0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "''' 使用扩展矩阵方法计算最优的拟合直线 '''\n",
    "\n",
    "# 将x从一维数组转成列数组，然后扩充一列全为1的列。以方便矩阵乘积运算\n",
    "X = np.c_[x[:, np.newaxis], np.ones(len(x))]\n",
    "\n",
    "# 根据上面的矩阵运算公式计算W\n",
    "W = np.linalg.inv(X.T.dot(X)).dot(X.T).dot(y)       \n",
    "print(W)\n",
    "\n",
    "# 使用拟合函数重新计算每个样本点的y值\n",
    "y_fit = X.dot(W)         \n",
    "\n",
    "plt.scatter(x, y)\n",
    "plt.plot(x, y_fit)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **步骤2-方法3：使用scipy的leastsq方法求解$w_0$和$w_1$**  \n",
    "* scipy.optimize对象的leastsq用于对给定的残差序列进行最小二乘求解。  \n",
    "* 在调用leastsq函数之前，必须先做好两个准备：  \n",
    "  1. 定义求残差的函数。该函数的第一个参数必须是要求解的权重系数。一般来说，权重系数是一个数组（例如，在一元线性回归中，有$w_1$和$w_0$两个权重系数，它们构成一个一维数组$W$。\n",
    "  2. 为权重系数提供初值。一般可以采用随机初始化的方式。再次注意，权重系数是一个数组。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 6.  1.]\n",
      " [ 8.  1.]\n",
      " [10.  1.]\n",
      " [14.  1.]\n",
      " [18.  1.]]\n",
      "result= (array([0.97629309, 1.9655174 ]), 1)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x20534fb8128>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "''' 使用leastsq方法求解线性拟合权重系数 '''\n",
    "\n",
    "# 将x从一维数组转成列数组，然后扩充一列全为1的列。以方便矩阵乘积运算\n",
    "x_ext = np.c_[x[:, np.newaxis], np.ones(len(x))]\n",
    "print(x_ext)\n",
    "\n",
    "# 定义线性拟合函数\n",
    "# 注意X的维度：(5, 2)  W的维度：(2, )\n",
    "def fit_function(W, X):   \n",
    "    return np.dot(X, W)\n",
    "\n",
    "# 定义残差函数\n",
    "# 注意该残差函数返回一个数组，数组中的每个元素正好是对应数据点的残差\n",
    "# 注意本例中X的维度：(5, 2)  W的维度：(2, )，返回值的维度：(5, )\n",
    "def error_function(W, X, y):\n",
    "    return fit_function(W, X) - y           # (5, )\n",
    "\n",
    "# 给定权重系数的初始值\n",
    "# 注意W的维度：(2, )\n",
    "w_init = np.random.rand(2)\n",
    "\n",
    "# 调用leastsq方法\n",
    "import scipy.optimize as opt\n",
    "result = opt.leastsq(error_function, w_init, args=(x_ext, y))\n",
    "# 查看result的内部结构和求值结果\n",
    "print(\"result=\", result)\n",
    "\n",
    "# result[0]中存放了W向量\n",
    "W = result[0]\n",
    "\n",
    "plt.scatter(x, y)\n",
    "plt.plot(x, fit_function(W, x_ext))     \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **案例2：单变量(一元)高阶曲线拟合**\n",
    "已知二维平面上若干数据点坐标 $(x_i,y_i)$如下：(-3, 14.2), (-2.3, 15.5), (-1.6, 14.8), (-1, 13.), (-0.3, 10.8), (0.3, 9.4), (1,0.4), (1.6, 11.8), (2.3, 17.5), (3, 27.4)  \n",
    "使用合适的曲线来拟合这些数据点"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **步骤1：作图查看数据点的特征**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2053521bb70>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.array([-3, -2.3, -1.6, -1, -0.3, 0.3, 1, 1.6, 2.3, 3])\n",
    "y = np.array([14.2, 15.5, 14.8, 13., 10.8, 9.4, 9.4, 11.8, 17.5, 27.4])\n",
    "\n",
    "# 绘制拟合曲线\n",
    "plt.scatter(x, y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **步骤2：选择合适的高阶曲线，并生成对应的扩展矩阵**  \n",
    "* 这些数据点显然无法用直线拟合。但可以考虑高阶曲线拟合，例如：$ y = w_3 x^3 + w_2 x^2 + w_1 x + w_0 $   \n",
    "* 高阶曲线不是线性的，因此不能直接通过线性方法来高效求解。但是可以在对数据进行变换后，可以将高阶转换成一阶多元(维度)，从而进行线性处理。  \n",
    "* 将原来的一元三阶变量转换成三元一阶矩阵(考虑到追加一个全为1的列，实际上有4个列)，此时的拟合曲线变为：$y = w_3 x_3 + w_2 x_2 + w_1 x_1 + w_0$  \n",
    "上式中的$x_3, x_2, x_1$都是一阶变量，其中$x_3$相当于原先的$x^3$,$x_2$相当于原先的$x^2$,$x_1$相当于原先的$x^1$   \n",
    "* 设：$ \\begin{matrix} \\\\\n",
    "X=\\left(\\begin{matrix}\n",
    "x_1^n & x_1^{n-1} & \\cdots & x_1 & 1 \\\\\n",
    "x_2^n & x_2^{n-1} & \\cdots & x_2 & 1 \\\\\n",
    "\\vdots & \\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
    "x_m^n & x_m^{n-1} & \\cdots & x_m & 1\n",
    "\\end{matrix}\\right) \\\\\n",
    "\\end{matrix}$；\n",
    "$w=[w_n,\\cdots,w_1,w_0]$  \n",
    "接下来就可按照$Xw$线性方法求解"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-2.7000e+01  9.0000e+00 -3.0000e+00  1.0000e+00]\n",
      " [-1.2167e+01  5.2900e+00 -2.3000e+00  1.0000e+00]\n",
      " [-4.0960e+00  2.5600e+00 -1.6000e+00  1.0000e+00]\n",
      " [-1.0000e+00  1.0000e+00 -1.0000e+00  1.0000e+00]\n",
      " [-2.7000e-02  9.0000e-02 -3.0000e-01  1.0000e+00]\n",
      " [ 2.7000e-02  9.0000e-02  3.0000e-01  1.0000e+00]\n",
      " [ 1.0000e+00  1.0000e+00  1.0000e+00  1.0000e+00]\n",
      " [ 4.0960e+00  2.5600e+00  1.6000e+00  1.0000e+00]\n",
      " [ 1.2167e+01  5.2900e+00  2.3000e+00  1.0000e+00]\n",
      " [ 2.7000e+01  9.0000e+00  3.0000e+00  1.0000e+00]]\n"
     ]
    }
   ],
   "source": [
    "''' 生成扩展矩阵 '''\n",
    "\n",
    "def make_x_ext(x_org):\n",
    "    x_ext = np.c_[x_org[:,np.newaxis], np.ones(len(x_org))]         # 追加全1列\n",
    "    x_ext = np.insert(x_ext, 0, np.power(x_org, 2), axis=1)     # 插入x*x数据列\n",
    "    x_ext = np.insert(x_ext, 0, np.power(x_org, 3), axis=1)     # 插入x*x*x数据列\n",
    "    return x_ext\n",
    "\n",
    "X = make_x_ext(x)\n",
    "print(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **步骤3-方法1：使用矩阵运算求解多元一阶变量的最小二乘解**  \n",
    "$ W=(X^T X)^{-1} X^T y $  \n",
    "上式中，$X$为上述三元一阶矩阵(外加一个全为1的列)，$W$对应的是一个具有4个元素的向量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2053520bef0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "''' 使用矩阵算法拟合三阶曲线 '''\n",
    "\n",
    "W = np.linalg.inv(X.T.dot(X)).dot(X.T).dot(y)\n",
    "\n",
    "# 绘制拟合曲线\n",
    "x_fit = np.linspace(-3, 3, 50)  # 给定一批x数据点\n",
    "X_fit = make_x_ext(x_fit)       # 将其扩展为一阶矩阵\n",
    "y_fit = np.dot(X_fit, W)        # 采用矩阵运算计算其拟合的结果\n",
    "# 也可以采用下列方式计算拟合结果\n",
    "# y_fit = W[0] * x_fit**3 + W[1] * x_fit**2 + W[2] * x_fit + W[3]\n",
    "plt.plot(x_fit, y_fit)          # 作出拟合的曲线图\n",
    "\n",
    "plt.scatter(x, y)               # 绘制原始数据点\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **步骤3-方法2：使用leastsq方法求解多元一阶变量的最小二乘解**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.49012809  1.20100243 -2.19801393 10.07080327]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x205352e6080>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "''' 使用leastsq方法拟合三阶曲线 '''\n",
    "\n",
    "# 定义拟合函数\n",
    "def fit_function(W, X):\n",
    "    return np.dot(X, W)\n",
    "\n",
    "# 定义残差函数\n",
    "def error_function(W, X, y):\n",
    "    return fit_function(W, X) - y\n",
    "\n",
    "# 初始化权重参数\n",
    "w_init = np.random.rand(4)\n",
    "x_ext = make_x_ext(x)\n",
    "# 传入残差函数(也就是目标函数)、初始值\n",
    "# 将扩展矩阵和y值放在一个tuple参数中传入\n",
    "result = opt.leastsq(error_function, w_init, args=(x_ext, y))\n",
    "w = result[0]\n",
    "print(w)            # 各个参数应该接近：0.5, 1.2, -2.3, 10\n",
    "\n",
    "# 绘制拟合曲线\n",
    "x_fit = np.linspace(-3, 3, 50)\n",
    "x_fit_ext = make_x_ext(x_fit)\n",
    "y_fit = fit_function(w, x_fit_ext)\n",
    "plt.plot(x_fit, y_fit)\n",
    "\n",
    "plt.scatter(x, y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **案例3：多元高阶拟合**\n",
    "对于有多个自变量，同时每个自变量又存在高阶的情形，基本方法仍然是将每个高阶变量转换成一个单独的新变量，然后形成相应的多元矩阵，最后使用leastsq方法进行最小二乘求解  \n",
    "本案例使用的数据点样本来源于函数：$y=3x_1^2-5x_1 x_2+3x_2^2-8x_1-10x_2+6$ (加了一个随机的小扰动)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **步骤1：查看空间曲面数据点(二元二阶)**\n",
    "* 为了显示三维空间的数据点，需要使用mpl_toolkits.mplot3d.Axes3D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x205352df2b0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "''' 查看三位空间数据点 '''\n",
    "from mpl_toolkits.mplot3d import Axes3D  \n",
    "\n",
    "# 用于生成样本数据点的函数 \n",
    "def f(x1, x2):\n",
    "    # np.random.random()是为了给样本数据一个小的扰动\n",
    "    return 3 * x1 * x1 - 5 * x1 * x2 + 2 * x2 * x2 - 8 * x1 - 10 * x2 + 6 + np.random.random()\n",
    "\n",
    "# 给定一批原始数据点的x1和x2两个方向坐标\n",
    "x1 = np.linspace(-3, 3, 6)\n",
    "x2 = np.linspace(-3, 3, 6)\n",
    "y = np.zeros(len(x1) * len(x2))\n",
    "# 根据x1和x2中的每个组合，分别计算对应的y值\n",
    "y_index = 0\n",
    "for i in np.arange(len(x1)):\n",
    "    for j in np.arange(len(x2)):\n",
    "        y[y_index] = f(x1[i], x2[j])\n",
    "        y_index += 1\n",
    "\n",
    "# 在三维空间绘制图像\n",
    "ax = plt.figure().add_subplot(111, projection='3d')  \n",
    "x_grid = np.meshgrid(x1, x2)\n",
    "ax.scatter(x_grid[0], x_grid[1], y)                             # 绘制散点\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **步骤2：生成多元矩阵**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 9.    9.    9.   -3.   -3.    1.  ]\n",
      " [ 9.    5.4   3.24 -3.   -1.8   1.  ]\n",
      " [ 9.    1.8   0.36 -3.   -0.6   1.  ]\n",
      " [ 9.   -1.8   0.36 -3.    0.6   1.  ]\n",
      " [ 9.   -5.4   3.24 -3.    1.8   1.  ]\n",
      " [ 9.   -9.    9.   -3.    3.    1.  ]\n",
      " [ 3.24  5.4   9.   -1.8  -3.    1.  ]\n",
      " [ 3.24  3.24  3.24 -1.8  -1.8   1.  ]\n",
      " [ 3.24  1.08  0.36 -1.8  -0.6   1.  ]\n",
      " [ 3.24 -1.08  0.36 -1.8   0.6   1.  ]\n",
      " [ 3.24 -3.24  3.24 -1.8   1.8   1.  ]\n",
      " [ 3.24 -5.4   9.   -1.8   3.    1.  ]\n",
      " [ 0.36  1.8   9.   -0.6  -3.    1.  ]\n",
      " [ 0.36  1.08  3.24 -0.6  -1.8   1.  ]\n",
      " [ 0.36  0.36  0.36 -0.6  -0.6   1.  ]\n",
      " [ 0.36 -0.36  0.36 -0.6   0.6   1.  ]\n",
      " [ 0.36 -1.08  3.24 -0.6   1.8   1.  ]\n",
      " [ 0.36 -1.8   9.   -0.6   3.    1.  ]\n",
      " [ 0.36 -1.8   9.    0.6  -3.    1.  ]\n",
      " [ 0.36 -1.08  3.24  0.6  -1.8   1.  ]\n",
      " [ 0.36 -0.36  0.36  0.6  -0.6   1.  ]\n",
      " [ 0.36  0.36  0.36  0.6   0.6   1.  ]\n",
      " [ 0.36  1.08  3.24  0.6   1.8   1.  ]\n",
      " [ 0.36  1.8   9.    0.6   3.    1.  ]\n",
      " [ 3.24 -5.4   9.    1.8  -3.    1.  ]\n",
      " [ 3.24 -3.24  3.24  1.8  -1.8   1.  ]\n",
      " [ 3.24 -1.08  0.36  1.8  -0.6   1.  ]\n",
      " [ 3.24  1.08  0.36  1.8   0.6   1.  ]\n",
      " [ 3.24  3.24  3.24  1.8   1.8   1.  ]\n",
      " [ 3.24  5.4   9.    1.8   3.    1.  ]\n",
      " [ 9.   -9.    9.    3.   -3.    1.  ]\n",
      " [ 9.   -5.4   3.24  3.   -1.8   1.  ]\n",
      " [ 9.   -1.8   0.36  3.   -0.6   1.  ]\n",
      " [ 9.    1.8   0.36  3.    0.6   1.  ]\n",
      " [ 9.    5.4   3.24  3.    1.8   1.  ]\n",
      " [ 9.    9.    9.    3.    3.    1.  ]]\n"
     ]
    }
   ],
   "source": [
    "POLY_COUNT = 6                  # 2阶多项式一共6项\n",
    "def map_data(X1, X2):           # 生成两个变量的多元一阶矩阵\n",
    "    variables = np.ones((len(X1) * len(X2), POLY_COUNT))\n",
    "    y = np.zeros((len(X1) * len(X2)))\n",
    "    row_index = 0\n",
    "    for i in np.arange(len(X1)):\n",
    "        for j in np.arange(len(X2)):\n",
    "            row = variables[row_index]\n",
    "            row[0] = X1[i] * X1[i]\n",
    "            row[1] = X1[i] * X2[j]\n",
    "            row[2] = X2[j] * X2[j]\n",
    "            row[3] = X1[i]\n",
    "            row[4] = X2[j]\n",
    "            y[row_index] = f(X1[i], X2[j])\n",
    "            #row[5] = 1\n",
    "            row_index += 1\n",
    "    return (variables, y)\n",
    "\n",
    "# 生成扩展矩阵及对应的y值\n",
    "x_ext, y = map_data(x1, x2)\n",
    "print(x_ext)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **步骤3：使用leastsq求取最优解**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 3.01365394 -4.97961967  1.98709079 -8.01447328 -9.97794902  6.48308589]\n"
     ]
    }
   ],
   "source": [
    "# 定义拟合函数(使用扩展矩阵的形式)\n",
    "# 此处的X_ext必须是已经形成x1*x1, x1*x2，x2*x2,x1,x2,1共6列的数据矩阵\n",
    "def fit_function(W, X_ext):\n",
    "    return np.dot(X_ext, W)\n",
    "\n",
    "# 定义残差函数(使用扩展矩阵的形式)\n",
    "# 此处的X_ext必须是已经形成x1*x1, x1*x2，x2*x2,x1,x2,1共6列的数据矩阵\n",
    "def error_function(W, X_ext, y):\n",
    "    return fit_function(W, X_ext) - y\n",
    "\n",
    "w_init = np.random.randn(POLY_COUNT)            # 初始化w\n",
    "result = opt.leastsq(error_function, w_init, args=(x_ext, y))\n",
    "\n",
    "w = result[0]\n",
    "print(w)                # 拟合参数应接近：[  3.  -5.   2.  -8. -10.   6.]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **步骤4：作图查看拟合效果**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x205351f9ac8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 下列函数利用拟合出来的W参数对新的X1和X2数据进行计算\n",
    "def predict_function(W, X1, X2):\n",
    "    return W[0] * X1 * X1 + W[1] * X1 * X2 + W[2] * X2 * X2 + W[3] * X1 + W[4] * X2 + W[5]\n",
    "\n",
    "# 在三维空间绘制图像\n",
    "ax = plt.figure().add_subplot(111, projection='3d')  \n",
    "x_grid = np.meshgrid(x1, x2)\n",
    "ax.scatter(x_grid[0], x_grid[1], y)                             # 绘制散点\n",
    "\n",
    "# 使用拟合函数计算曲面上的点阵\n",
    "x1_fit = np.linspace(-3, 3, 12)\n",
    "x2_fit = np.linspace(-3, 3, 12)\n",
    "x_fit_grid = np.meshgrid(x1_fit, x2_fit)\n",
    "y_fit = predict_function(w, x_fit_grid[0], x_fit_grid[1])\n",
    "ax.plot_surface(x_fit_grid[0], x_fit_grid[1], y_fit)            # 绘制曲面\n",
    "\n",
    "ax.set_xlabel('X1')  \n",
    "ax.set_ylabel('X2')  \n",
    "ax.set_zlabel('Y')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
